user_expressions: bool = Bool(False, help="Process user_expressions in cell metadata")

    async def async_execute_cell(
            self,
            cell: NotebookNode,
            cell_index: int,
            execution_count: t.Optional[int] = None,
            store_history: bool = True) -> NotebookNode:
        """
        Executes a single code cell...
        """
        assert self.kc is not None
        if cell.cell_type != 'code' or not cell.source.strip():
            self.log.debug("Skipping non-executing cell %s", cell_index)
            return cell

        if self.record_timing and 'execution' not in cell['metadata']:
            cell['metadata']['execution'] = {}

        self.log.debug("Executing cell:\n%s", cell.source)

        cell_allows_errors = (not self.force_raise_errors) and (
            self.allow_errors
            or "raises-exception" in cell.metadata.get("tags", []))

        # retrieve desired user expressions from the metadata (validate type?)
        user_expressions = cell.metadata.get('user_expressions', None) if self.user_expressions else None

        parent_msg_id = await ensure_async(
            self.kc.execute(
                cell.source,
                store_history=store_history,
                stop_on_error=not cell_allows_errors,
                user_expressions=user_expressions,
            )
        )
        # We launched a code cell to execute
        self.code_cells_executed += 1
        exec_timeout = self._get_timeout(cell)

        cell.outputs = []
        self.clear_before_next_output = False

        # clear any existing user_expressions outputs
        # note, it would be ideal if these could be a top-level key in the cell (rather than in the metadata),
        # but nbformat/v4/nbformat.v4.5.schema.json does not allow additional properties on the code cell
        if self.user_expressions:
            cell.metadata.pop('user_expressions_outputs', None)

        task_poll_kernel_alive = asyncio.ensure_future(
            self._async_poll_kernel_alive()
        )
        task_poll_output_msg = asyncio.ensure_future(
            self._async_poll_output_msg(parent_msg_id, cell, cell_index)
        )
        self.task_poll_for_reply = asyncio.ensure_future(
            self._async_poll_for_reply(
                parent_msg_id, cell, exec_timeout, task_poll_output_msg, task_poll_kernel_alive
            )
        )
        try:
            exec_reply = await self.task_poll_for_reply
        except asyncio.CancelledError:
            # can only be cancelled by task_poll_kernel_alive when the kernel is dead
            task_poll_output_msg.cancel()
            raise DeadKernelError("Kernel died")
        except Exception as e:
            # Best effort to cancel request if it hasn't been resolved
            try:
                # Check if the task_poll_output is doing the raising for us
                if not isinstance(e, CellControlSignal):
                    task_poll_output_msg.cancel()
            finally:
                raise

        # add user_expressions outputs, if present
        if self.user_expressions and 'user_expressions' in exec_reply['content']:
            cell.metadata['user_expressions_outputs'] = exec_reply['content']['user_expressions']

        if execution_count:
            cell['execution_count'] = execution_count
        self._check_raise_for_error(cell, exec_reply)
        self.nb['cells'][cell_index] = cell

        return cell

In [1]: import nbformat, nbclient
In [2]: client = nbclient.NotebookClient(nbformat.read(open("test.ipynb"), as_version=4), user_expressions=True)
In [3]: client.execute()
Out[3]: 
{'cells': [{'cell_type': 'code',
   'execution_count': 1,
   'metadata': {'user_expressions': {'key': 'a'},
    'execution': {'iopub.status.busy': '2022-01-05T16:46:25.294446Z',
     'iopub.execute_input': '2022-01-05T16:46:25.295670Z',
     'iopub.status.idle': '2022-01-05T16:46:25.307139Z',
     'shell.execute_reply': '2022-01-05T16:46:25.307858Z'},
    'user_expressions_outputs': {'key': {'status': 'ok',
      'data': {'text/plain': '1'},
      'metadata': {}}}},
   'outputs': [],
   'source': 'a = 1'}],
 'metadata': {'language_info': {'name': 'python',
   'version': '3.7.10',
   'mimetype': 'text/x-python',
   'codemirror_mode': {'name': 'ipython', 'version': 3},
   'pygments_lexer': 'ipython3',
   'nbconvert_exporter': 'python',
   'file_extension': '.py'}},
 'nbformat': 4,
 'nbformat_minor': 2}